home *** CD-ROM | disk | FTP | other *** search
/ Clickx 115 / Clickx 115.iso / software / tools / windows / tails-i386-0.16.iso / live / filesystem.squashfs / usr / lib / python2.6 / compiler / ast.py < prev    next >
Encoding:
Python Source  |  2010-12-26  |  35.0 KB  |  1,359 lines
  1. """Python abstract syntax node definitions
  2.  
  3. This file is automatically generated by Tools/compiler/astgen.py
  4. """
  5. from compiler.consts import CO_VARARGS, CO_VARKEYWORDS
  6.  
  7. def flatten(seq):
  8.     l = []
  9.     for elt in seq:
  10.         t = type(elt)
  11.         if t is tuple or t is list:
  12.             for elt2 in flatten(elt):
  13.                 l.append(elt2)
  14.         else:
  15.             l.append(elt)
  16.     return l
  17.  
  18. def flatten_nodes(seq):
  19.     return [n for n in flatten(seq) if isinstance(n, Node)]
  20.  
  21. nodes = {}
  22.  
  23. class Node:
  24.     """Abstract base class for ast nodes."""
  25.     def getChildren(self):
  26.         pass # implemented by subclasses
  27.     def __iter__(self):
  28.         for n in self.getChildren():
  29.             yield n
  30.     def asList(self): # for backwards compatibility
  31.         return self.getChildren()
  32.     def getChildNodes(self):
  33.         pass # implemented by subclasses
  34.  
  35. class EmptyNode(Node):
  36.     pass
  37.  
  38. class Expression(Node):
  39.     # Expression is an artificial node class to support "eval"
  40.     nodes["expression"] = "Expression"
  41.     def __init__(self, node):
  42.         self.node = node
  43.  
  44.     def getChildren(self):
  45.         return self.node,
  46.  
  47.     def getChildNodes(self):
  48.         return self.node,
  49.  
  50.     def __repr__(self):
  51.         return "Expression(%s)" % (repr(self.node))
  52.  
  53. class Add(Node):
  54.     def __init__(self, leftright, lineno=None):
  55.         self.left = leftright[0]
  56.         self.right = leftright[1]
  57.         self.lineno = lineno
  58.  
  59.     def getChildren(self):
  60.         return self.left, self.right
  61.  
  62.     def getChildNodes(self):
  63.         return self.left, self.right
  64.  
  65.     def __repr__(self):
  66.         return "Add((%s, %s))" % (repr(self.left), repr(self.right))
  67.  
  68. class And(Node):
  69.     def __init__(self, nodes, lineno=None):
  70.         self.nodes = nodes
  71.         self.lineno = lineno
  72.  
  73.     def getChildren(self):
  74.         return tuple(flatten(self.nodes))
  75.  
  76.     def getChildNodes(self):
  77.         nodelist = []
  78.         nodelist.extend(flatten_nodes(self.nodes))
  79.         return tuple(nodelist)
  80.  
  81.     def __repr__(self):
  82.         return "And(%s)" % (repr(self.nodes),)
  83.  
  84. class AssAttr(Node):
  85.     def __init__(self, expr, attrname, flags, lineno=None):
  86.         self.expr = expr
  87.         self.attrname = attrname
  88.         self.flags = flags
  89.         self.lineno = lineno
  90.  
  91.     def getChildren(self):
  92.         return self.expr, self.attrname, self.flags
  93.  
  94.     def getChildNodes(self):
  95.         return self.expr,
  96.  
  97.     def __repr__(self):
  98.         return "AssAttr(%s, %s, %s)" % (repr(self.expr), repr(self.attrname), repr(self.flags))
  99.  
  100. class AssList(Node):
  101.     def __init__(self, nodes, lineno=None):
  102.         self.nodes = nodes
  103.         self.lineno = lineno
  104.  
  105.     def getChildren(self):
  106.         return tuple(flatten(self.nodes))
  107.  
  108.     def getChildNodes(self):
  109.         nodelist = []
  110.         nodelist.extend(flatten_nodes(self.nodes))
  111.         return tuple(nodelist)
  112.  
  113.     def __repr__(self):
  114.         return "AssList(%s)" % (repr(self.nodes),)
  115.  
  116. class AssName(Node):
  117.     def __init__(self, name, flags, lineno=None):
  118.         self.name = name
  119.         self.flags = flags
  120.         self.lineno = lineno
  121.  
  122.     def getChildren(self):
  123.         return self.name, self.flags
  124.  
  125.     def getChildNodes(self):
  126.         return ()
  127.  
  128.     def __repr__(self):
  129.         return "AssName(%s, %s)" % (repr(self.name), repr(self.flags))
  130.  
  131. class AssTuple(Node):
  132.     def __init__(self, nodes, lineno=None):
  133.         self.nodes = nodes
  134.         self.lineno = lineno
  135.  
  136.     def getChildren(self):
  137.         return tuple(flatten(self.nodes))
  138.  
  139.     def getChildNodes(self):
  140.         nodelist = []
  141.         nodelist.extend(flatten_nodes(self.nodes))
  142.         return tuple(nodelist)
  143.  
  144.     def __repr__(self):
  145.         return "AssTuple(%s)" % (repr(self.nodes),)
  146.  
  147. class Assert(Node):
  148.     def __init__(self, test, fail, lineno=None):
  149.         self.test = test
  150.         self.fail = fail
  151.         self.lineno = lineno
  152.  
  153.     def getChildren(self):
  154.         children = []
  155.         children.append(self.test)
  156.         children.append(self.fail)
  157.         return tuple(children)
  158.  
  159.     def getChildNodes(self):
  160.         nodelist = []
  161.         nodelist.append(self.test)
  162.         if self.fail is not None:
  163.             nodelist.append(self.fail)
  164.         return tuple(nodelist)
  165.  
  166.     def __repr__(self):
  167.         return "Assert(%s, %s)" % (repr(self.test), repr(self.fail))
  168.  
  169. class Assign(Node):
  170.     def __init__(self, nodes, expr, lineno=None):
  171.         self.nodes = nodes
  172.         self.expr = expr
  173.         self.lineno = lineno
  174.  
  175.     def getChildren(self):
  176.         children = []
  177.         children.extend(flatten(self.nodes))
  178.         children.append(self.expr)
  179.         return tuple(children)
  180.  
  181.     def getChildNodes(self):
  182.         nodelist = []
  183.         nodelist.extend(flatten_nodes(self.nodes))
  184.         nodelist.append(self.expr)
  185.         return tuple(nodelist)
  186.  
  187.     def __repr__(self):
  188.         return "Assign(%s, %s)" % (repr(self.nodes), repr(self.expr))
  189.  
  190. class AugAssign(Node):
  191.     def __init__(self, node, op, expr, lineno=None):
  192.         self.node = node
  193.         self.op = op
  194.         self.expr = expr
  195.         self.lineno = lineno
  196.  
  197.     def getChildren(self):
  198.         return self.node, self.op, self.expr
  199.  
  200.     def getChildNodes(self):
  201.         return self.node, self.expr
  202.  
  203.     def __repr__(self):
  204.         return "AugAssign(%s, %s, %s)" % (repr(self.node), repr(self.op), repr(self.expr))
  205.  
  206. class Backquote(Node):
  207.     def __init__(self, expr, lineno=None):
  208.         self.expr = expr
  209.         self.lineno = lineno
  210.  
  211.     def getChildren(self):
  212.         return self.expr,
  213.  
  214.     def getChildNodes(self):
  215.         return self.expr,
  216.  
  217.     def __repr__(self):
  218.         return "Backquote(%s)" % (repr(self.expr),)
  219.  
  220. class Bitand(Node):
  221.     def __init__(self, nodes, lineno=None):
  222.         self.nodes = nodes
  223.         self.lineno = lineno
  224.  
  225.     def getChildren(self):
  226.         return tuple(flatten(self.nodes))
  227.  
  228.     def getChildNodes(self):
  229.         nodelist = []
  230.         nodelist.extend(flatten_nodes(self.nodes))
  231.         return tuple(nodelist)
  232.  
  233.     def __repr__(self):
  234.         return "Bitand(%s)" % (repr(self.nodes),)
  235.  
  236. class Bitor(Node):
  237.     def __init__(self, nodes, lineno=None):
  238.         self.nodes = nodes
  239.         self.lineno = lineno
  240.  
  241.     def getChildren(self):
  242.         return tuple(flatten(self.nodes))
  243.  
  244.     def getChildNodes(self):
  245.         nodelist = []
  246.         nodelist.extend(flatten_nodes(self.nodes))
  247.         return tuple(nodelist)
  248.  
  249.     def __repr__(self):
  250.         return "Bitor(%s)" % (repr(self.nodes),)
  251.  
  252. class Bitxor(Node):
  253.     def __init__(self, nodes, lineno=None):
  254.         self.nodes = nodes
  255.         self.lineno = lineno
  256.  
  257.     def getChildren(self):
  258.         return tuple(flatten(self.nodes))
  259.  
  260.     def getChildNodes(self):
  261.         nodelist = []
  262.         nodelist.extend(flatten_nodes(self.nodes))
  263.         return tuple(nodelist)
  264.  
  265.     def __repr__(self):
  266.         return "Bitxor(%s)" % (repr(self.nodes),)
  267.  
  268. class Break(Node):
  269.     def __init__(self, lineno=None):
  270.         self.lineno = lineno
  271.  
  272.     def getChildren(self):
  273.         return ()
  274.  
  275.     def getChildNodes(self):
  276.         return ()
  277.  
  278.     def __repr__(self):
  279.         return "Break()"
  280.  
  281. class CallFunc(Node):
  282.     def __init__(self, node, args, star_args = None, dstar_args = None, lineno=None):
  283.         self.node = node
  284.         self.args = args
  285.         self.star_args = star_args
  286.         self.dstar_args = dstar_args
  287.         self.lineno = lineno
  288.  
  289.     def getChildren(self):
  290.         children = []
  291.         children.append(self.node)
  292.         children.extend(flatten(self.args))
  293.         children.append(self.star_args)
  294.         children.append(self.dstar_args)
  295.         return tuple(children)
  296.  
  297.     def getChildNodes(self):
  298.         nodelist = []
  299.         nodelist.append(self.node)
  300.         nodelist.extend(flatten_nodes(self.args))
  301.         if self.star_args is not None:
  302.             nodelist.append(self.star_args)
  303.         if self.dstar_args is not None:
  304.             nodelist.append(self.dstar_args)
  305.         return tuple(nodelist)
  306.  
  307.     def __repr__(self):
  308.         return "CallFunc(%s, %s, %s, %s)" % (repr(self.node), repr(self.args), repr(self.star_args), repr(self.dstar_args))
  309.  
  310. class Class(Node):
  311.     def __init__(self, name, bases, doc, code, decorators = None, lineno=None):
  312.         self.name = name
  313.         self.bases = bases
  314.         self.doc = doc
  315.         self.code = code
  316.         self.decorators = decorators
  317.         self.lineno = lineno
  318.  
  319.     def getChildren(self):
  320.         children = []
  321.         children.append(self.name)
  322.         children.extend(flatten(self.bases))
  323.         children.append(self.doc)
  324.         children.append(self.code)
  325.         children.append(self.decorators)
  326.         return tuple(children)
  327.  
  328.     def getChildNodes(self):
  329.         nodelist = []
  330.         nodelist.extend(flatten_nodes(self.bases))
  331.         nodelist.append(self.code)
  332.         if self.decorators is not None:
  333.             nodelist.append(self.decorators)
  334.         return tuple(nodelist)
  335.  
  336.     def __repr__(self):
  337.         return "Class(%s, %s, %s, %s, %s)" % (repr(self.name), repr(self.bases), repr(self.doc), repr(self.code), repr(self.decorators))
  338.  
  339. class Compare(Node):
  340.     def __init__(self, expr, ops, lineno=None):
  341.         self.expr = expr
  342.         self.ops = ops
  343.         self.lineno = lineno
  344.  
  345.     def getChildren(self):
  346.         children = []
  347.         children.append(self.expr)
  348.         children.extend(flatten(self.ops))
  349.         return tuple(children)
  350.  
  351.     def getChildNodes(self):
  352.         nodelist = []
  353.         nodelist.append(self.expr)
  354.         nodelist.extend(flatten_nodes(self.ops))
  355.         return tuple(nodelist)
  356.  
  357.     def __repr__(self):
  358.         return "Compare(%s, %s)" % (repr(self.expr), repr(self.ops))
  359.  
  360. class Const(Node):
  361.     def __init__(self, value, lineno=None):
  362.         self.value = value
  363.         self.lineno = lineno
  364.  
  365.     def getChildren(self):
  366.         return self.value,
  367.  
  368.     def getChildNodes(self):
  369.         return ()
  370.  
  371.     def __repr__(self):
  372.         return "Const(%s)" % (repr(self.value),)
  373.  
  374. class Continue(Node):
  375.     def __init__(self, lineno=None):
  376.         self.lineno = lineno
  377.  
  378.     def getChildren(self):
  379.         return ()
  380.  
  381.     def getChildNodes(self):
  382.         return ()
  383.  
  384.     def __repr__(self):
  385.         return "Continue()"
  386.  
  387. class Decorators(Node):
  388.     def __init__(self, nodes, lineno=None):
  389.         self.nodes = nodes
  390.         self.lineno = lineno
  391.  
  392.     def getChildren(self):
  393.         return tuple(flatten(self.nodes))
  394.  
  395.     def getChildNodes(self):
  396.         nodelist = []
  397.         nodelist.extend(flatten_nodes(self.nodes))
  398.         return tuple(nodelist)
  399.  
  400.     def __repr__(self):
  401.         return "Decorators(%s)" % (repr(self.nodes),)
  402.  
  403. class Dict(Node):
  404.     def __init__(self, items, lineno=None):
  405.         self.items = items
  406.         self.lineno = lineno
  407.  
  408.     def getChildren(self):
  409.         return tuple(flatten(self.items))
  410.  
  411.     def getChildNodes(self):
  412.         nodelist = []
  413.         nodelist.extend(flatten_nodes(self.items))
  414.         return tuple(nodelist)
  415.  
  416.     def __repr__(self):
  417.         return "Dict(%s)" % (repr(self.items),)
  418.  
  419. class Discard(Node):
  420.     def __init__(self, expr, lineno=None):
  421.         self.expr = expr
  422.         self.lineno = lineno
  423.  
  424.     def getChildren(self):
  425.         return self.expr,
  426.  
  427.     def getChildNodes(self):
  428.         return self.expr,
  429.  
  430.     def __repr__(self):
  431.         return "Discard(%s)" % (repr(self.expr),)
  432.  
  433. class Div(Node):
  434.     def __init__(self, leftright, lineno=None):
  435.         self.left = leftright[0]
  436.         self.right = leftright[1]
  437.         self.lineno = lineno
  438.  
  439.     def getChildren(self):
  440.         return self.left, self.right
  441.  
  442.     def getChildNodes(self):
  443.         return self.left, self.right
  444.  
  445.     def __repr__(self):
  446.         return "Div((%s, %s))" % (repr(self.left), repr(self.right))
  447.  
  448. class Ellipsis(Node):
  449.     def __init__(self, lineno=None):
  450.         self.lineno = lineno
  451.  
  452.     def getChildren(self):
  453.         return ()
  454.  
  455.     def getChildNodes(self):
  456.         return ()
  457.  
  458.     def __repr__(self):
  459.         return "Ellipsis()"
  460.  
  461. class Exec(Node):
  462.     def __init__(self, expr, locals, globals, lineno=None):
  463.         self.expr = expr
  464.         self.locals = locals
  465.         self.globals = globals
  466.         self.lineno = lineno
  467.  
  468.     def getChildren(self):
  469.         children = []
  470.         children.append(self.expr)
  471.         children.append(self.locals)
  472.         children.append(self.globals)
  473.         return tuple(children)
  474.  
  475.     def getChildNodes(self):
  476.         nodelist = []
  477.         nodelist.append(self.expr)
  478.         if self.locals is not None:
  479.             nodelist.append(self.locals)
  480.         if self.globals is not None:
  481.             nodelist.append(self.globals)
  482.         return tuple(nodelist)
  483.  
  484.     def __repr__(self):
  485.         return "Exec(%s, %s, %s)" % (repr(self.expr), repr(self.locals), repr(self.globals))
  486.  
  487. class FloorDiv(Node):
  488.     def __init__(self, leftright, lineno=None):
  489.         self.left = leftright[0]
  490.         self.right = leftright[1]
  491.         self.lineno = lineno
  492.  
  493.     def getChildren(self):
  494.         return self.left, self.right
  495.  
  496.     def getChildNodes(self):
  497.         return self.left, self.right
  498.  
  499.     def __repr__(self):
  500.         return "FloorDiv((%s, %s))" % (repr(self.left), repr(self.right))
  501.  
  502. class For(Node):
  503.     def __init__(self, assign, list, body, else_, lineno=None):
  504.         self.assign = assign
  505.         self.list = list
  506.         self.body = body
  507.         self.else_ = else_
  508.         self.lineno = lineno
  509.  
  510.     def getChildren(self):
  511.         children = []
  512.         children.append(self.assign)
  513.         children.append(self.list)
  514.         children.append(self.body)
  515.         children.append(self.else_)
  516.         return tuple(children)
  517.  
  518.     def getChildNodes(self):
  519.         nodelist = []
  520.         nodelist.append(self.assign)
  521.         nodelist.append(self.list)
  522.         nodelist.append(self.body)
  523.         if self.else_ is not None:
  524.             nodelist.append(self.else_)
  525.         return tuple(nodelist)
  526.  
  527.     def __repr__(self):
  528.         return "For(%s, %s, %s, %s)" % (repr(self.assign), repr(self.list), repr(self.body), repr(self.else_))
  529.  
  530. class From(Node):
  531.     def __init__(self, modname, names, level, lineno=None):
  532.         self.modname = modname
  533.         self.names = names
  534.         self.level = level
  535.         self.lineno = lineno
  536.  
  537.     def getChildren(self):
  538.         return self.modname, self.names, self.level
  539.  
  540.     def getChildNodes(self):
  541.         return ()
  542.  
  543.     def __repr__(self):
  544.         return "From(%s, %s, %s)" % (repr(self.modname), repr(self.names), repr(self.level))
  545.  
  546. class Function(Node):
  547.     def __init__(self, decorators, name, argnames, defaults, flags, doc, code, lineno=None):
  548.         self.decorators = decorators
  549.         self.name = name
  550.         self.argnames = argnames
  551.         self.defaults = defaults
  552.         self.flags = flags
  553.         self.doc = doc
  554.         self.code = code
  555.         self.lineno = lineno
  556.         self.varargs = self.kwargs = None
  557.         if flags & CO_VARARGS:
  558.             self.varargs = 1
  559.         if flags & CO_VARKEYWORDS:
  560.             self.kwargs = 1
  561.  
  562.  
  563.     def getChildren(self):
  564.         children = []
  565.         children.append(self.decorators)
  566.         children.append(self.name)
  567.         children.append(self.argnames)
  568.         children.extend(flatten(self.defaults))
  569.         children.append(self.flags)
  570.         children.append(self.doc)
  571.         children.append(self.code)
  572.         return tuple(children)
  573.  
  574.     def getChildNodes(self):
  575.         nodelist = []
  576.         if self.decorators is not None:
  577.             nodelist.append(self.decorators)
  578.         nodelist.extend(flatten_nodes(self.defaults))
  579.         nodelist.append(self.code)
  580.         return tuple(nodelist)
  581.  
  582.     def __repr__(self):
  583.         return "Function(%s, %s, %s, %s, %s, %s, %s)" % (repr(self.decorators), repr(self.name), repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.doc), repr(self.code))
  584.  
  585. class GenExpr(Node):
  586.     def __init__(self, code, lineno=None):
  587.         self.code = code
  588.         self.lineno = lineno
  589.         self.argnames = ['.0']
  590.         self.varargs = self.kwargs = None
  591.  
  592.  
  593.     def getChildren(self):
  594.         return self.code,
  595.  
  596.     def getChildNodes(self):
  597.         return self.code,
  598.  
  599.     def __repr__(self):
  600.         return "GenExpr(%s)" % (repr(self.code),)
  601.  
  602. class GenExprFor(Node):
  603.     def __init__(self, assign, iter, ifs, lineno=None):
  604.         self.assign = assign
  605.         self.iter = iter
  606.         self.ifs = ifs
  607.         self.lineno = lineno
  608.         self.is_outmost = False
  609.  
  610.     def getChildren(self):
  611.         children = []
  612.         children.append(self.assign)
  613.         children.append(self.iter)
  614.         children.extend(flatten(self.ifs))
  615.         return tuple(children)
  616.  
  617.     def getChildNodes(self):
  618.         nodelist = []
  619.         nodelist.append(self.assign)
  620.         nodelist.append(self.iter)
  621.         nodelist.extend(flatten_nodes(self.ifs))
  622.         return tuple(nodelist)
  623.  
  624.     def __repr__(self):
  625.         return "GenExprFor(%s, %s, %s)" % (repr(self.assign), repr(self.iter), repr(self.ifs))
  626.  
  627. class GenExprIf(Node):
  628.     def __init__(self, test, lineno=None):
  629.         self.test = test
  630.         self.lineno = lineno
  631.  
  632.     def getChildren(self):
  633.         return self.test,
  634.  
  635.     def getChildNodes(self):
  636.         return self.test,
  637.  
  638.     def __repr__(self):
  639.         return "GenExprIf(%s)" % (repr(self.test),)
  640.  
  641. class GenExprInner(Node):
  642.     def __init__(self, expr, quals, lineno=None):
  643.         self.expr = expr
  644.         self.quals = quals
  645.         self.lineno = lineno
  646.  
  647.     def getChildren(self):
  648.         children = []
  649.         children.append(self.expr)
  650.         children.extend(flatten(self.quals))
  651.         return tuple(children)
  652.  
  653.     def getChildNodes(self):
  654.         nodelist = []
  655.         nodelist.append(self.expr)
  656.         nodelist.extend(flatten_nodes(self.quals))
  657.         return tuple(nodelist)
  658.  
  659.     def __repr__(self):
  660.         return "GenExprInner(%s, %s)" % (repr(self.expr), repr(self.quals))
  661.  
  662. class Getattr(Node):
  663.     def __init__(self, expr, attrname, lineno=None):
  664.         self.expr = expr
  665.         self.attrname = attrname
  666.         self.lineno = lineno
  667.  
  668.     def getChildren(self):
  669.         return self.expr, self.attrname
  670.  
  671.     def getChildNodes(self):
  672.         return self.expr,
  673.  
  674.     def __repr__(self):
  675.         return "Getattr(%s, %s)" % (repr(self.expr), repr(self.attrname))
  676.  
  677. class Global(Node):
  678.     def __init__(self, names, lineno=None):
  679.         self.names = names
  680.         self.lineno = lineno
  681.  
  682.     def getChildren(self):
  683.         return self.names,
  684.  
  685.     def getChildNodes(self):
  686.         return ()
  687.  
  688.     def __repr__(self):
  689.         return "Global(%s)" % (repr(self.names),)
  690.  
  691. class If(Node):
  692.     def __init__(self, tests, else_, lineno=None):
  693.         self.tests = tests
  694.         self.else_ = else_
  695.         self.lineno = lineno
  696.  
  697.     def getChildren(self):
  698.         children = []
  699.         children.extend(flatten(self.tests))
  700.         children.append(self.else_)
  701.         return tuple(children)
  702.  
  703.     def getChildNodes(self):
  704.         nodelist = []
  705.         nodelist.extend(flatten_nodes(self.tests))
  706.         if self.else_ is not None:
  707.             nodelist.append(self.else_)
  708.         return tuple(nodelist)
  709.  
  710.     def __repr__(self):
  711.         return "If(%s, %s)" % (repr(self.tests), repr(self.else_))
  712.  
  713. class IfExp(Node):
  714.     def __init__(self, test, then, else_, lineno=None):
  715.         self.test = test
  716.         self.then = then
  717.         self.else_ = else_
  718.         self.lineno = lineno
  719.  
  720.     def getChildren(self):
  721.         return self.test, self.then, self.else_
  722.  
  723.     def getChildNodes(self):
  724.         return self.test, self.then, self.else_
  725.  
  726.     def __repr__(self):
  727.         return "IfExp(%s, %s, %s)" % (repr(self.test), repr(self.then), repr(self.else_))
  728.  
  729. class Import(Node):
  730.     def __init__(self, names, lineno=None):
  731.         self.names = names
  732.         self.lineno = lineno
  733.  
  734.     def getChildren(self):
  735.         return self.names,
  736.  
  737.     def getChildNodes(self):
  738.         return ()
  739.  
  740.     def __repr__(self):
  741.         return "Import(%s)" % (repr(self.names),)
  742.  
  743. class Invert(Node):
  744.     def __init__(self, expr, lineno=None):
  745.         self.expr = expr
  746.         self.lineno = lineno
  747.  
  748.     def getChildren(self):
  749.         return self.expr,
  750.  
  751.     def getChildNodes(self):
  752.         return self.expr,
  753.  
  754.     def __repr__(self):
  755.         return "Invert(%s)" % (repr(self.expr),)
  756.  
  757. class Keyword(Node):
  758.     def __init__(self, name, expr, lineno=None):
  759.         self.name = name
  760.         self.expr = expr
  761.         self.lineno = lineno
  762.  
  763.     def getChildren(self):
  764.         return self.name, self.expr
  765.  
  766.     def getChildNodes(self):
  767.         return self.expr,
  768.  
  769.     def __repr__(self):
  770.         return "Keyword(%s, %s)" % (repr(self.name), repr(self.expr))
  771.  
  772. class Lambda(Node):
  773.     def __init__(self, argnames, defaults, flags, code, lineno=None):
  774.         self.argnames = argnames
  775.         self.defaults = defaults
  776.         self.flags = flags
  777.         self.code = code
  778.         self.lineno = lineno
  779.         self.varargs = self.kwargs = None
  780.         if flags & CO_VARARGS:
  781.             self.varargs = 1
  782.         if flags & CO_VARKEYWORDS:
  783.             self.kwargs = 1
  784.  
  785.  
  786.     def getChildren(self):
  787.         children = []
  788.         children.append(self.argnames)
  789.         children.extend(flatten(self.defaults))
  790.         children.append(self.flags)
  791.         children.append(self.code)
  792.         return tuple(children)
  793.  
  794.     def getChildNodes(self):
  795.         nodelist = []
  796.         nodelist.extend(flatten_nodes(self.defaults))
  797.         nodelist.append(self.code)
  798.         return tuple(nodelist)
  799.  
  800.     def __repr__(self):
  801.         return "Lambda(%s, %s, %s, %s)" % (repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.code))
  802.  
  803. class LeftShift(Node):
  804.     def __init__(self, leftright, lineno=None):
  805.         self.left = leftright[0]
  806.         self.right = leftright[1]
  807.         self.lineno = lineno
  808.  
  809.     def getChildren(self):
  810.         return self.left, self.right
  811.  
  812.     def getChildNodes(self):
  813.         return self.left, self.right
  814.  
  815.     def __repr__(self):
  816.         return "LeftShift((%s, %s))" % (repr(self.left), repr(self.right))
  817.  
  818. class List(Node):
  819.     def __init__(self, nodes, lineno=None):
  820.         self.nodes = nodes
  821.         self.lineno = lineno
  822.  
  823.     def getChildren(self):
  824.         return tuple(flatten(self.nodes))
  825.  
  826.     def getChildNodes(self):
  827.         nodelist = []
  828.         nodelist.extend(flatten_nodes(self.nodes))
  829.         return tuple(nodelist)
  830.  
  831.     def __repr__(self):
  832.         return "List(%s)" % (repr(self.nodes),)
  833.  
  834. class ListComp(Node):
  835.     def __init__(self, expr, quals, lineno=None):
  836.         self.expr = expr
  837.         self.quals = quals
  838.         self.lineno = lineno
  839.  
  840.     def getChildren(self):
  841.         children = []
  842.         children.append(self.expr)
  843.         children.extend(flatten(self.quals))
  844.         return tuple(children)
  845.  
  846.     def getChildNodes(self):
  847.         nodelist = []
  848.         nodelist.append(self.expr)
  849.         nodelist.extend(flatten_nodes(self.quals))
  850.         return tuple(nodelist)
  851.  
  852.     def __repr__(self):
  853.         return "ListComp(%s, %s)" % (repr(self.expr), repr(self.quals))
  854.  
  855. class ListCompFor(Node):
  856.     def __init__(self, assign, list, ifs, lineno=None):
  857.         self.assign = assign
  858.         self.list = list
  859.         self.ifs = ifs
  860.         self.lineno = lineno
  861.  
  862.     def getChildren(self):
  863.         children = []
  864.         children.append(self.assign)
  865.         children.append(self.list)
  866.         children.extend(flatten(self.ifs))
  867.         return tuple(children)
  868.  
  869.     def getChildNodes(self):
  870.         nodelist = []
  871.         nodelist.append(self.assign)
  872.         nodelist.append(self.list)
  873.         nodelist.extend(flatten_nodes(self.ifs))
  874.         return tuple(nodelist)
  875.  
  876.     def __repr__(self):
  877.         return "ListCompFor(%s, %s, %s)" % (repr(self.assign), repr(self.list), repr(self.ifs))
  878.  
  879. class ListCompIf(Node):
  880.     def __init__(self, test, lineno=None):
  881.         self.test = test
  882.         self.lineno = lineno
  883.  
  884.     def getChildren(self):
  885.         return self.test,
  886.  
  887.     def getChildNodes(self):
  888.         return self.test,
  889.  
  890.     def __repr__(self):
  891.         return "ListCompIf(%s)" % (repr(self.test),)
  892.  
  893. class Mod(Node):
  894.     def __init__(self, leftright, lineno=None):
  895.         self.left = leftright[0]
  896.         self.right = leftright[1]
  897.         self.lineno = lineno
  898.  
  899.     def getChildren(self):
  900.         return self.left, self.right
  901.  
  902.     def getChildNodes(self):
  903.         return self.left, self.right
  904.  
  905.     def __repr__(self):
  906.         return "Mod((%s, %s))" % (repr(self.left), repr(self.right))
  907.  
  908. class Module(Node):
  909.     def __init__(self, doc, node, lineno=None):
  910.         self.doc = doc
  911.         self.node = node
  912.         self.lineno = lineno
  913.  
  914.     def getChildren(self):
  915.         return self.doc, self.node
  916.  
  917.     def getChildNodes(self):
  918.         return self.node,
  919.  
  920.     def __repr__(self):
  921.         return "Module(%s, %s)" % (repr(self.doc), repr(self.node))
  922.  
  923. class Mul(Node):
  924.     def __init__(self, leftright, lineno=None):
  925.         self.left = leftright[0]
  926.         self.right = leftright[1]
  927.         self.lineno = lineno
  928.  
  929.     def getChildren(self):
  930.         return self.left, self.right
  931.  
  932.     def getChildNodes(self):
  933.         return self.left, self.right
  934.  
  935.     def __repr__(self):
  936.         return "Mul((%s, %s))" % (repr(self.left), repr(self.right))
  937.  
  938. class Name(Node):
  939.     def __init__(self, name, lineno=None):
  940.         self.name = name
  941.         self.lineno = lineno
  942.  
  943.     def getChildren(self):
  944.         return self.name,
  945.  
  946.     def getChildNodes(self):
  947.         return ()
  948.  
  949.     def __repr__(self):
  950.         return "Name(%s)" % (repr(self.name),)
  951.  
  952. class Not(Node):
  953.     def __init__(self, expr, lineno=None):
  954.         self.expr = expr
  955.         self.lineno = lineno
  956.  
  957.     def getChildren(self):
  958.         return self.expr,
  959.  
  960.     def getChildNodes(self):
  961.         return self.expr,
  962.  
  963.     def __repr__(self):
  964.         return "Not(%s)" % (repr(self.expr),)
  965.  
  966. class Or(Node):
  967.     def __init__(self, nodes, lineno=None):
  968.         self.nodes = nodes
  969.         self.lineno = lineno
  970.  
  971.     def getChildren(self):
  972.         return tuple(flatten(self.nodes))
  973.  
  974.     def getChildNodes(self):
  975.         nodelist = []
  976.         nodelist.extend(flatten_nodes(self.nodes))
  977.         return tuple(nodelist)
  978.  
  979.     def __repr__(self):
  980.         return "Or(%s)" % (repr(self.nodes),)
  981.  
  982. class Pass(Node):
  983.     def __init__(self, lineno=None):
  984.         self.lineno = lineno
  985.  
  986.     def getChildren(self):
  987.         return ()
  988.  
  989.     def getChildNodes(self):
  990.         return ()
  991.  
  992.     def __repr__(self):
  993.         return "Pass()"
  994.  
  995. class Power(Node):
  996.     def __init__(self, leftright, lineno=None):
  997.         self.left = leftright[0]
  998.         self.right = leftright[1]
  999.         self.lineno = lineno
  1000.  
  1001.     def getChildren(self):
  1002.         return self.left, self.right
  1003.  
  1004.     def getChildNodes(self):
  1005.         return self.left, self.right
  1006.  
  1007.     def __repr__(self):
  1008.         return "Power((%s, %s))" % (repr(self.left), repr(self.right))
  1009.  
  1010. class Print(Node):
  1011.     def __init__(self, nodes, dest, lineno=None):
  1012.         self.nodes = nodes
  1013.         self.dest = dest
  1014.         self.lineno = lineno
  1015.  
  1016.     def getChildren(self):
  1017.         children = []
  1018.         children.extend(flatten(self.nodes))
  1019.         children.append(self.dest)
  1020.         return tuple(children)
  1021.  
  1022.     def getChildNodes(self):
  1023.         nodelist = []
  1024.         nodelist.extend(flatten_nodes(self.nodes))
  1025.         if self.dest is not None:
  1026.             nodelist.append(self.dest)
  1027.         return tuple(nodelist)
  1028.  
  1029.     def __repr__(self):
  1030.         return "Print(%s, %s)" % (repr(self.nodes), repr(self.dest))
  1031.  
  1032. class Printnl(Node):
  1033.     def __init__(self, nodes, dest, lineno=None):
  1034.         self.nodes = nodes
  1035.         self.dest = dest
  1036.         self.lineno = lineno
  1037.  
  1038.     def getChildren(self):
  1039.         children = []
  1040.         children.extend(flatten(self.nodes))
  1041.         children.append(self.dest)
  1042.         return tuple(children)
  1043.  
  1044.     def getChildNodes(self):
  1045.         nodelist = []
  1046.         nodelist.extend(flatten_nodes(self.nodes))
  1047.         if self.dest is not None:
  1048.             nodelist.append(self.dest)
  1049.         return tuple(nodelist)
  1050.  
  1051.     def __repr__(self):
  1052.         return "Printnl(%s, %s)" % (repr(self.nodes), repr(self.dest))
  1053.  
  1054. class Raise(Node):
  1055.     def __init__(self, expr1, expr2, expr3, lineno=None):
  1056.         self.expr1 = expr1
  1057.         self.expr2 = expr2
  1058.         self.expr3 = expr3
  1059.         self.lineno = lineno
  1060.  
  1061.     def getChildren(self):
  1062.         children = []
  1063.         children.append(self.expr1)
  1064.         children.append(self.expr2)
  1065.         children.append(self.expr3)
  1066.         return tuple(children)
  1067.  
  1068.     def getChildNodes(self):
  1069.         nodelist = []
  1070.         if self.expr1 is not None:
  1071.             nodelist.append(self.expr1)
  1072.         if self.expr2 is not None:
  1073.             nodelist.append(self.expr2)
  1074.         if self.expr3 is not None:
  1075.             nodelist.append(self.expr3)
  1076.         return tuple(nodelist)
  1077.  
  1078.     def __repr__(self):
  1079.         return "Raise(%s, %s, %s)" % (repr(self.expr1), repr(self.expr2), repr(self.expr3))
  1080.  
  1081. class Return(Node):
  1082.     def __init__(self, value, lineno=None):
  1083.         self.value = value
  1084.         self.lineno = lineno
  1085.  
  1086.     def getChildren(self):
  1087.         return self.value,
  1088.  
  1089.     def getChildNodes(self):
  1090.         return self.value,
  1091.  
  1092.     def __repr__(self):
  1093.         return "Return(%s)" % (repr(self.value),)
  1094.  
  1095. class RightShift(Node):
  1096.     def __init__(self, leftright, lineno=None):
  1097.         self.left = leftright[0]
  1098.         self.right = leftright[1]
  1099.         self.lineno = lineno
  1100.  
  1101.     def getChildren(self):
  1102.         return self.left, self.right
  1103.  
  1104.     def getChildNodes(self):
  1105.         return self.left, self.right
  1106.  
  1107.     def __repr__(self):
  1108.         return "RightShift((%s, %s))" % (repr(self.left), repr(self.right))
  1109.  
  1110. class Slice(Node):
  1111.     def __init__(self, expr, flags, lower, upper, lineno=None):
  1112.         self.expr = expr
  1113.         self.flags = flags
  1114.         self.lower = lower
  1115.         self.upper = upper
  1116.         self.lineno = lineno
  1117.  
  1118.     def getChildren(self):
  1119.         children = []
  1120.         children.append(self.expr)
  1121.         children.append(self.flags)
  1122.         children.append(self.lower)
  1123.         children.append(self.upper)
  1124.         return tuple(children)
  1125.  
  1126.     def getChildNodes(self):
  1127.         nodelist = []
  1128.         nodelist.append(self.expr)
  1129.         if self.lower is not None:
  1130.             nodelist.append(self.lower)
  1131.         if self.upper is not None:
  1132.             nodelist.append(self.upper)
  1133.         return tuple(nodelist)
  1134.  
  1135.     def __repr__(self):
  1136.         return "Slice(%s, %s, %s, %s)" % (repr(self.expr), repr(self.flags), repr(self.lower), repr(self.upper))
  1137.  
  1138. class Sliceobj(Node):
  1139.     def __init__(self, nodes, lineno=None):
  1140.         self.nodes = nodes
  1141.         self.lineno = lineno
  1142.  
  1143.     def getChildren(self):
  1144.         return tuple(flatten(self.nodes))
  1145.  
  1146.     def getChildNodes(self):
  1147.         nodelist = []
  1148.         nodelist.extend(flatten_nodes(self.nodes))
  1149.         return tuple(nodelist)
  1150.  
  1151.     def __repr__(self):
  1152.         return "Sliceobj(%s)" % (repr(self.nodes),)
  1153.  
  1154. class Stmt(Node):
  1155.     def __init__(self, nodes, lineno=None):
  1156.         self.nodes = nodes
  1157.         self.lineno = lineno
  1158.  
  1159.     def getChildren(self):
  1160.         return tuple(flatten(self.nodes))
  1161.  
  1162.     def getChildNodes(self):
  1163.         nodelist = []
  1164.         nodelist.extend(flatten_nodes(self.nodes))
  1165.         return tuple(nodelist)
  1166.  
  1167.     def __repr__(self):
  1168.         return "Stmt(%s)" % (repr(self.nodes),)
  1169.  
  1170. class Sub(Node):
  1171.     def __init__(self, leftright, lineno=None):
  1172.         self.left = leftright[0]
  1173.         self.right = leftright[1]
  1174.         self.lineno = lineno
  1175.  
  1176.     def getChildren(self):
  1177.         return self.left, self.right
  1178.  
  1179.     def getChildNodes(self):
  1180.         return self.left, self.right
  1181.  
  1182.     def __repr__(self):
  1183.         return "Sub((%s, %s))" % (repr(self.left), repr(self.right))
  1184.  
  1185. class Subscript(Node):
  1186.     def __init__(self, expr, flags, subs, lineno=None):
  1187.         self.expr = expr
  1188.         self.flags = flags
  1189.         self.subs = subs
  1190.         self.lineno = lineno
  1191.  
  1192.     def getChildren(self):
  1193.         children = []
  1194.         children.append(self.expr)
  1195.         children.append(self.flags)
  1196.         children.extend(flatten(self.subs))
  1197.         return tuple(children)
  1198.  
  1199.     def getChildNodes(self):
  1200.         nodelist = []
  1201.         nodelist.append(self.expr)
  1202.         nodelist.extend(flatten_nodes(self.subs))
  1203.         return tuple(nodelist)
  1204.  
  1205.     def __repr__(self):
  1206.         return "Subscript(%s, %s, %s)" % (repr(self.expr), repr(self.flags), repr(self.subs))
  1207.  
  1208. class TryExcept(Node):
  1209.     def __init__(self, body, handlers, else_, lineno=None):
  1210.         self.body = body
  1211.         self.handlers = handlers
  1212.         self.else_ = else_
  1213.         self.lineno = lineno
  1214.  
  1215.     def getChildren(self):
  1216.         children = []
  1217.         children.append(self.body)
  1218.         children.extend(flatten(self.handlers))
  1219.         children.append(self.else_)
  1220.         return tuple(children)
  1221.  
  1222.     def getChildNodes(self):
  1223.         nodelist = []
  1224.         nodelist.append(self.body)
  1225.         nodelist.extend(flatten_nodes(self.handlers))
  1226.         if self.else_ is not None:
  1227.             nodelist.append(self.else_)
  1228.         return tuple(nodelist)
  1229.  
  1230.     def __repr__(self):
  1231.         return "TryExcept(%s, %s, %s)" % (repr(self.body), repr(self.handlers), repr(self.else_))
  1232.  
  1233. class TryFinally(Node):
  1234.     def __init__(self, body, final, lineno=None):
  1235.         self.body = body
  1236.         self.final = final
  1237.         self.lineno = lineno
  1238.  
  1239.     def getChildren(self):
  1240.         return self.body, self.final
  1241.  
  1242.     def getChildNodes(self):
  1243.         return self.body, self.final
  1244.  
  1245.     def __repr__(self):
  1246.         return "TryFinally(%s, %s)" % (repr(self.body), repr(self.final))
  1247.  
  1248. class Tuple(Node):
  1249.     def __init__(self, nodes, lineno=None):
  1250.         self.nodes = nodes
  1251.         self.lineno = lineno
  1252.  
  1253.     def getChildren(self):
  1254.         return tuple(flatten(self.nodes))
  1255.  
  1256.     def getChildNodes(self):
  1257.         nodelist = []
  1258.         nodelist.extend(flatten_nodes(self.nodes))
  1259.         return tuple(nodelist)
  1260.  
  1261.     def __repr__(self):
  1262.         return "Tuple(%s)" % (repr(self.nodes),)
  1263.  
  1264. class UnaryAdd(Node):
  1265.     def __init__(self, expr, lineno=None):
  1266.         self.expr = expr
  1267.         self.lineno = lineno
  1268.  
  1269.     def getChildren(self):
  1270.         return self.expr,
  1271.  
  1272.     def getChildNodes(self):
  1273.         return self.expr,
  1274.  
  1275.     def __repr__(self):
  1276.         return "UnaryAdd(%s)" % (repr(self.expr),)
  1277.  
  1278. class UnarySub(Node):
  1279.     def __init__(self, expr, lineno=None):
  1280.         self.expr = expr
  1281.         self.lineno = lineno
  1282.  
  1283.     def getChildren(self):
  1284.         return self.expr,
  1285.  
  1286.     def getChildNodes(self):
  1287.         return self.expr,
  1288.  
  1289.     def __repr__(self):
  1290.         return "UnarySub(%s)" % (repr(self.expr),)
  1291.  
  1292. class While(Node):
  1293.     def __init__(self, test, body, else_, lineno=None):
  1294.         self.test = test
  1295.         self.body = body
  1296.         self.else_ = else_
  1297.         self.lineno = lineno
  1298.  
  1299.     def getChildren(self):
  1300.         children = []
  1301.         children.append(self.test)
  1302.         children.append(self.body)
  1303.         children.append(self.else_)
  1304.         return tuple(children)
  1305.  
  1306.     def getChildNodes(self):
  1307.         nodelist = []
  1308.         nodelist.append(self.test)
  1309.         nodelist.append(self.body)
  1310.         if self.else_ is not None:
  1311.             nodelist.append(self.else_)
  1312.         return tuple(nodelist)
  1313.  
  1314.     def __repr__(self):
  1315.         return "While(%s, %s, %s)" % (repr(self.test), repr(self.body), repr(self.else_))
  1316.  
  1317. class With(Node):
  1318.     def __init__(self, expr, vars, body, lineno=None):
  1319.         self.expr = expr
  1320.         self.vars = vars
  1321.         self.body = body
  1322.         self.lineno = lineno
  1323.  
  1324.     def getChildren(self):
  1325.         children = []
  1326.         children.append(self.expr)
  1327.         children.append(self.vars)
  1328.         children.append(self.body)
  1329.         return tuple(children)
  1330.  
  1331.     def getChildNodes(self):
  1332.         nodelist = []
  1333.         nodelist.append(self.expr)
  1334.         if self.vars is not None:
  1335.             nodelist.append(self.vars)
  1336.         nodelist.append(self.body)
  1337.         return tuple(nodelist)
  1338.  
  1339.     def __repr__(self):
  1340.         return "With(%s, %s, %s)" % (repr(self.expr), repr(self.vars), repr(self.body))
  1341.  
  1342. class Yield(Node):
  1343.     def __init__(self, value, lineno=None):
  1344.         self.value = value
  1345.         self.lineno = lineno
  1346.  
  1347.     def getChildren(self):
  1348.         return self.value,
  1349.  
  1350.     def getChildNodes(self):
  1351.         return self.value,
  1352.  
  1353.     def __repr__(self):
  1354.         return "Yield(%s)" % (repr(self.value),)
  1355.  
  1356. for name, obj in globals().items():
  1357.     if isinstance(obj, type) and issubclass(obj, Node):
  1358.         nodes[name.lower()] = obj
  1359.